Collecties of objectverzamelingen

Als we slechts een klein aantal objecten gebruiken is er niets op tegen om aan elk van die objecten een eigen naam te geven. In bepaalde omstandigheden is het echter onmogelijk om die objecten individueel bij te houden.

Als er te veel objecten zijn.
Als we van te voren niet weten hoeveel objecten er zullen zijn.

Inleiding

Er bestaan verschillende oplossingen voor dat probleem. Jullie kennen allemaal al de zogeheten arrays. Arrays hebben echter twee nadelen:

Het aantal elementen van de array moet van tevoren vastgelegd worden. In vele gevallen weten we echter niet hoeveel objecten we zullen gebruiken. Het zou zonde van het computergeheugen zijn om voor één miljoen objecten geheugenruimte vrij te maken en tenslotte maar drie objecten gebruiken.
Als we een waardetype in een array plaatsen en vervolgens een kopie van die array maken en in de kopie een wijziging aanbrengen is er niets aan de hand. Alleen in de kopie wordt de wijziging doorgevoerd. Maar klassen zijn geen waardetypen maar referentietypen. Als we een object in een array plaatsen en we maken een kopie van de array dan wordt er geen kopie van het object gemaakt maar een kopie van de verwijzing. In een array van objecten wordt slechts de verwijzing naar die objecten opgenomen.

Hier hebben we het over speciale klassen die gemaakt zijn om andere objecten in een lijst bij te houden. Het is handig om bepaalde objecten te kunnen groeperen en ze ook als groep te kunnen manipuleren. Tezelfdertijd willen we elk individueel object ook kunnen aanspreken. Collecties zijn speciale klassen waarin naar een reeks van andere objecten kan worden gerefereerd.

Collecties zijn zelf ook objecten en dat betekent dat:

Collecties moeten geïnstancieerd worden vooraleer ze te gebruiken zijn.
Collecties hebben eigenschappen voor bijvoorbeeld het aantal objecten en methoden voor bijvoorbeeld het toevoegen en verwijderen van objecten.
Als instantie van een klasse kunnen collecties profiteren van standaard objectgeoriënteerde mogelijkheden zoals overerving en encapsulatie.

De klasse ArrayList

Deze gegevensstructuur zit in de namespace met de naam System.Collections.

Als elementen worden toegevoegd aan een ArrayList, wordt de capaciteit automatisch verhoogd.

Indexen in deze collectie zijn zero-based.

ArrayList accepteert een null-referentie als een geldige waarde en laat dubbele elementen toe.

In het volgende voorbeeld wordt de enumerator van een ArrayList opgehaald en de enumerator voor een aantal elementen in de ArrayList.

In de klasse TryOut in de namespace DotNetCore.Learning:

voeg de volgende directive toe:
```
using System.Collections;
```

en de methode:

public static void ArrayListSample()
{
    ArrayList colors = new ArrayList();
    colors.Add("red");
    colors.Add("blue");
    colors.Add("green");
    colors.Add("yellow");
    colors.Add("beige");
    colors.Add("brown");
    colors.Add("magenta");
    colors.Add("purple");

    IEnumerator e = colors.GetEnumerator();
    while (e.MoveNext())
    {
        Object obj = e.Current;
        Console.WriteLine(obj);
    }

    Console.WriteLine();

    IEnumerator e2 = colors.GetEnumerator(2, 4);
    while (e2.MoveNext())
    {
        Object obj = e2.Current;
        Console.WriteLine(obj);
    }
}

We proberen die uit in de Main methode van de Program klasse in het bestand Program.cs:

using System;

namespace DotNetCore.Learning
{
    class Program
    {

        static void Main(string[] args)
        {
            //Console.WriteLine(TryOut.ReadFromCSVFile());
            TryOut.ArrayListSample();
            Console.ReadKey();
        }
    }
}

/* This code example produces
the following ouput:
red
blue
green
yellow
beige
brown
magenta
purple

green
yellow
beige
brown
*/

De klasse Dictionary<TKey, Tvalue>

De Dictionary<TKey, Tvalue> generieke klasse voorziet in een overeenkomsttabel van een set trefwoorden met een set van waarden. Elke toevoeging aan het woordenboek bestaat uit een waarde en het bijbehorende trefwoord. Het ophalen van een waarde met behulp van een trefwoord is zeer snel omdat de Dictionary<TKey, Tvalue> klasse geïmplementeerd is als een hash table.

In de klasse TryOut in de namespace DotNetCore.Learning:

Voeg de volgende directive toe:
```
using System.Collections;
```

En de methode:

public static void DictionarySample()
{
    // Create a new dictionary of strings, with string keys.
    //
    Dictionary<string, string> openWith =
        new Dictionary<string, string>();

    // Add some elements to the dictionary. There are no
    // duplicate keys, but some of the values are duplicates.
    openWith.Add("txt", "notepad.exe");
    openWith.Add("bmp", "paint.exe");
    openWith.Add("dib", "paint.exe");
    openWith.Add("rtf", "wordpad.exe");

    // The Add method throws an exception if the new key is
    // already in the dictionary.
    try
    {
        openWith.Add("txt", "winword.exe");
    }
    catch (ArgumentException)
    {
        Console.WriteLine("An element with Key = \"txt\" already exists.");
    }

    // The Item property is another name for the indexer, so you
    // can omit its name when accessing elements.
    Console.WriteLine("For key = \"rtf\", value = {0}.",
        openWith["rtf"]);

    // The indexer can be used to change the value associated
    // with a key.
    openWith["rtf"] = "winword.exe";
    Console.WriteLine("For key = \"rtf\", value = {0}.",
        openWith["rtf"]);

    // If a key does not exist, setting the indexer for that key
    // adds a new key/value pair.
    openWith["doc"] = "winword.exe";

    // The indexer throws an exception if the requested key is
    // not in the dictionary.
    try
    {
        Console.WriteLine("For key = \"tif\", value = {0}.",
            openWith["tif"]);
    }
    catch (KeyNotFoundException)
    {
        Console.WriteLine("Key = \"tif\" is not found.");
    }

    // When a program often has to try keys that turn out not to
    // be in the dictionary, TryGetValue can be a more efficient
    // way to retrieve values.
    string value = "";
    if (openWith.TryGetValue("tif", out value))
    {
        Console.WriteLine("For key = \"tif\", value = {0}.", value);
    }
    else
    {
        Console.WriteLine("Key = \"tif\" is not found.");
    }

    // ContainsKey can be used to test keys before inserting
    // them.
    if (!openWith.ContainsKey("ht"))
    {
        openWith.Add("ht", "hypertrm.exe");
        Console.WriteLine("Value added for key = \"ht\": {0}",
            openWith["ht"]);
    }

    // When you use foreach to enumerate dictionary elements,
    // the elements are retrieved as KeyValuePair objects.
    Console.WriteLine();
    foreach (KeyValuePair<string, string> kvp in openWith)
    {
        Console.WriteLine("Key = {0}, Value = {1}",
            kvp.Key, kvp.Value);
    }

    // To get the values alone, use the Values property.
    Dictionary<string, string>.ValueCollection valueColl =
        openWith.Values;

    // The elements of the ValueCollection are strongly typed
    // with the type that was specified for dictionary values.
    Console.WriteLine();
    foreach (string s in valueColl)
    {
        Console.WriteLine("Value = {0}", s);
    }

    // To get the keys alone, use the Keys property.
    Dictionary<string, string>.KeyCollection keyColl =
        openWith.Keys;

    // The elements of the KeyCollection are strongly typed
    // with the type that was specified for dictionary keys.
    Console.WriteLine();
    foreach (string s in keyColl)
    {
        Console.WriteLine("Key = {0}", s);
    }

    // Use the Remove method to remove a key/value pair.
    Console.WriteLine("\nRemove(\"doc\")");
    openWith.Remove("doc");

    if (!openWith.ContainsKey("doc"))
    {
        Console.WriteLine("Key \"doc\" is not found.");
    }
}

/* This code example produces the following output:
An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

Value = notepad.exe
Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe
Value = hypertrm.exe

Key = txt
Key = bmp
Key = dib
Key = rtf
Key = doc
Key = ht

Remove("doc")
Key "doc" is not found.
*/

2017-10-06 10:40:10